// 初始化视频缓存信息
let videoFiles = uni.getStorageSync('VIDEO_FILES') || {};
// 用对象存储每个视频的下载状态，避免并发冲突
let downloading = {}; 
// 全局视频信息（应避免全局变量，建议通过返回值传递）
let videoPath = ''; 
let isVideoShow = false;

/**
 * 获取视频播放路径（优先使用缓存）
 * @param {Object} item - 包含视频信息的对象
 * @returns {Promise<Object>} 视频路径信息 {videoPath, videoPic}
 */
export default async function playVideo(item) {
  const videoId = item.timestamp;
  // 避免变量名重复（原代码中存在局部变量覆盖问题）
  const itemVideoInfo = item.content.videoPath; 

  // 1. 优先使用已保存的永久路径
  if (videoFiles[videoId]?.savedPath) {
	  console.log('有永久保存视频');
    return {
      videoPath: videoFiles[videoId].savedPath.videoPath,
      videoPic: videoFiles[videoId].savedPath.videoPic
    };
  }

  // 2. 检查临时文件是否存在
  if (videoFiles[videoId]?.tempPath) {
	   console.log('有保存临时视频');
    const videoExists = await checkFileExists(videoFiles[videoId].tempPath.videoPath);
    const picExists = await checkFileExists(videoFiles[videoId].tempPath.videoPic);
    
    if (videoExists && picExists) {
      return videoFiles[videoId].tempPath;
    }
    
    // 临时文件不存在，清除无效记录
    delete videoFiles[videoId].tempPath;
    updateStorage();
  }

  // 3. 开始下载（检查当前视频是否正在下载，避免重复下载）
  if (!downloading[videoId]) {
    const result = await downloadVideo(videoId, itemVideoInfo);
    return result;
  } else {
    // 如果正在下载，等待下载完成（轮询检查）
    return new Promise(resolve => {
      const checkDownload = setInterval(() => {
        if (!downloading[videoId] && videoFiles[videoId]?.tempPath) {
          clearInterval(checkDownload);
          resolve(videoFiles[videoId].tempPath);
        }
      }, 300);
    });
  }
}

/**
 * 检查文件是否存在（仅支持App端）
 * @param {string} filePath - 文件路径
 * @returns {Promise<boolean>} 文件是否存在
 */
function checkFileExists(filePath) {
  return new Promise((resolve) => {
    // 非App环境直接返回false（plus.io仅支持App）
    if (typeof plus === 'undefined') {
      resolve(false);
      return;
    }
    
    plus.io.resolveLocalFileSystemURL(
      filePath,
      () => resolve(true),  // 存在
      () => resolve(false)   // 不存在
    );
  }); 
}

/**
 * 下载视频和封面图
 * @param {string} videoId - 视频唯一标识
 * @param {Object} videoInfo - 包含视频和封面图URL的对象
 * @returns {Promise<Object>} 下载后的临时路径 {videoPath, videoPic}
 */
async function downloadVideo(videoId, videoInfo) {
  // 标记当前视频正在下载
  downloading[videoId] = true;
  try {
    // 并行下载视频和封面图（优化速度）
    const [videoRes, picRes] = await Promise.all([
      new Promise((resolve, reject) => {
        uni.downloadFile({
          url: videoInfo.videoPath.tempFileURL,
          success(res) {
            if (res.statusCode === 200) resolve(res.tempFilePath);
            else reject(new Error(`视频下载失败: ${res.statusCode}`));
          },
          fail(err) { reject(err); }
        });
      }),
      new Promise((resolve, reject) => {
        uni.downloadFile({
          url: videoInfo.videoPic.tempFileURL,
          success(res) {
            if (res.statusCode === 200) resolve(res.tempFilePath);
            else reject(new Error(`封面下载失败: ${res.statusCode}`));
          },
          fail(err) { reject(err); }
        });
      })
    ]);

    // 更新缓存信息
    if (!videoFiles[videoId]) videoFiles[videoId] = {};
    videoFiles[videoId].tempPath = {
      videoPath: videoRes,
      videoPic: picRes
    };
    updateStorage();

    // 更新全局变量（建议通过返回值传递，而非依赖全局变量）
    videoPath = videoRes;
    isVideoShow = true;

    return videoFiles[videoId].tempPath;

  } catch (err) {
    console.error('下载出错:', err);
    uni.showToast({ 
      title: err.message?.includes('404') ? '资源不存在' : '下载失败', 
      icon: 'none' 
    });
    throw err; // 抛出错误，让调用方处理
  } finally {
    // 清除下载状态
    downloading[videoId] = false;

  }
}

/**
 * 保存视频到本地（永久存储）
 * @param {string} videoId - 视频唯一标识
 * @returns {Promise<void>}
 */
async function saveVideo(videoId) {
  const videoInfo = videoFiles[videoId];
  if (!videoInfo?.tempPath) {
    uni.showToast({ title: '请先下载视频', icon: 'none' });
    return;
  }

  try {
    // 分别保存视频和封面图
    const [videoSaveRes, picSaveRes] = await Promise.all([
      uni.saveFile({ tempFilePath: videoInfo.tempPath.videoPath }),
      uni.saveFile({ tempFilePath: videoInfo.tempPath.videoPic })
    ]);

    // 更新为永久路径
    videoFiles[videoId].savedPath = {
      videoPath: videoSaveRes.savedFilePath,
      videoPic: picSaveRes.savedFilePath
    };
    // 保存后可清除临时路径（可选）
    delete videoFiles[videoId].tempPath;
    updateStorage();
    uni.showToast({ title: '保存成功' });
  } catch (err) {
    console.error('保存失败:', err);
    uni.showToast({ title: '保存失败', icon: 'none' });
  }
}

/**
 * 更新本地存储
 */
function updateStorage() {
  try {
    uni.setStorageSync('VIDEO_FILES', videoFiles);
  } catch (err) {
    console.error('存储视频信息失败:', err);
  }
}

/**
 * 获取视频信息（建议废弃全局变量，通过playVideo的返回值获取）
 * @returns {Object} 视频路径和显示状态
 */
export function getVideoInfo() {
  return {
    videoPath,
    isVideoShow
  };
}
